home *** CD-ROM | disk | FTP | other *** search
/ MacFormat España 13 / MacFormat n. 13 (Spain) / Macformat 13.bin / C de cerca / Ejemplos / Capitulo 1 / CdeCerca.c < prev   
Encoding:
C/C++ Source or Header  |  1996-02-07  |  6.1 KB  |  197 lines
  1. /*****************************************************************/
  2. /*
  3.         C de Cerca 1
  4.         Introducción al lenguaje C y su aplicación
  5.         para la programación del Mac
  6.             
  7.             Rafael Escoté - Enric Herrera
  8.             ©BlauSoft S.L. para MacFormat España - 1996
  9.                     
  10.             La descripción del código y la información sobre cómo preparar
  11.             el entorno de programación y generar estos programas, está contenida
  12.             en el ejemplar de MacFormat que los acompaña.
  13.                     
  14.  
  15. */
  16. /*****************************************************************/
  17.  
  18.  
  19.  
  20. /****************************************************************    */
  21. /* DECLARACION DE PROTOTIPOS DE LAS FUNCIONES QUE HEMOS CREADO        */
  22. /* EN NUESTRO PROGRAMA                                                                                        */ 
  23. /****************************************************************    */
  24. void        main(void);        /* Esta función NO puede tener otro nombre */
  25. void        MF_InitToolbox         (void);    /* Preparar el Mac */
  26. void         MF_AbreMiVentana    (void);    /* Abrir una ventana */
  27. void         MF_EscribeTexto        (void);    /* Poner en ella un texto */
  28. void         MF_bucle_principal(void);    /* Esperar acciones del usuario */
  29.  
  30.  
  31.  
  32. /****************************************************************    */
  33. /* CONSTANTES Y VARIABLES GLOBALES                                                                 */
  34. /* RELACIONADAS CON LA VENTANA QUE ABRIREMOS                                            */ 
  35. /****************************************************************    */
  36. /* La ventana que abriremos será creada dinámicamente por medio de
  37. la función NewWindow() que nos devolverá un puntero a la estructura de
  38. la nueva ventana, Declaramos pues, una variable adecuada... */
  39.  
  40. WindowPtr        gMiVentana = nil;
  41.  
  42.  
  43.                                                                 
  44. /*--------------------------------------------------------------------*/
  45. /* A PARTIR DE ESTE PUNTO, APARECE EL CODIGO DE LAS FUNCIONES CREADAS
  46.      ESPECIFICAMENTE PARA ESTE PROGRAMA. 
  47. /*--------------------------------------------------------------------*/
  48.  
  49.  
  50.  
  51. /****************************************************************    */
  52. /* FUNCION: main()                                                       */
  53. /****************************************************************    */
  54. /*
  55.     Todos los programas en C poseen una función que debe llamarse main.
  56.     Cuando un programa se pone en marcha, lo hace SIEMPRE ejecutando
  57.     en primer lugar la función main().
  58.     Es el punto de entrada a nuestra aplicación.
  59.     
  60.     Recibe:     nada
  61.     Que hace: Llama otras funciones que preparan la aplicación...
  62.     Salida:      void (nada)
  63. */
  64. void    main (void)
  65. {    
  66.     /* Antes de hacer nada, debemos preparar el entorno de nuestro programa.*/
  67.     /* Como sea que el procedimiento a seguir es casi siempre el mismo,            */
  68.     /* hemos creado una función MF_InitToolbox() que realiza la preparación */
  69.     /* adecuada */ 
  70.     MF_InitToolbox();
  71.     
  72.     /* Ahora empleamos una función que se encargará de abrir una ventana */
  73.     MF_AbreMiVentana();
  74.     
  75.     /* Una vez abierta la ventana, podemos escribir algo de texto en ella */
  76.     MF_EscribeTexto();
  77.     
  78.     /* Y ya podemos entrar en el bucle principal, que se encargará de
  79.          recoger e interpretar las acciones del usuario */    
  80.     MF_bucle_principal();
  81.     
  82.     /* Cuando el bucle principal haya terminado, será porque el usuario
  83.          desea acabar el programa.
  84.          Debemos liberar la memoria ocupada por nuestra ventana. */
  85.     DisposeWindow(gMiVentana);
  86.     
  87.   /* Y ya está, al acabarse la función main(), el Sistema cerrará
  88.          nuestra aplicación de forma automática */
  89.     
  90. } /* Fin de main() y del programa */
  91.  
  92.  
  93.  
  94.  
  95. /****************************************************************    */
  96. /* MF_bucle_principal                                                     */
  97. /****************************************************************    */
  98. /*
  99.     Recibe:     nada
  100.     Que hace: Entra en un bucle y espera que se produzca una acción
  101.                         En esta demo, simplemente esperamos que el usuario pulse una vez el
  102.                         botón del ratón. Cuando lo haga, la función acabará y el programa
  103.                         volverá a la función main().
  104.     Salida:      nada
  105. */
  106. void MF_bucle_principal(void)
  107. {
  108.     
  109.     while (Button() == 0) ;    /* Esperamos que el usuario pulse el botón */
  110.         
  111. } /* Fin de la función MF_bucle_principal() */
  112.  
  113.  
  114.  
  115. /****************************************************************    */
  116. /* MF_InitToolbox                                                                                                 */
  117. /****************************************************************    */
  118. /*
  119.     Inicializa la Toolbox Macintosh. El orden de llamada a las diversas
  120.     rutinas es significativo! No lo cambie.
  121.  
  122.     Recibe:     nada
  123.     Cambia:      nada en la aplicación
  124.     Salida:      nada
  125. */
  126. void MF_InitToolbox (void)
  127. {
  128.     InitGraf(&qd.thePort);
  129.     InitFonts();
  130.     FlushEvents(everyEvent,0);
  131.     InitWindows();
  132.     InitMenus();
  133.     TEInit();
  134.     InitDialogs(0L);
  135.     InitCursor();
  136.                                 
  137. } /* Fin de MF_InitToolbox() */
  138.  
  139.  
  140.  
  141. /****************************************************************    */
  142. /* MF_AbreMiVentana                                                       */
  143. /****************************************************************    */
  144. /*
  145.     Abre la ventana (la única) de nuestro programa. Las funciones empleadas
  146.     y el significado de los parámetros que utilizamos se comentarán en posteriores
  147.     versiones de esta aplicación.
  148.     
  149.     Recibe:     nada
  150.     Que hace: Crea una ventana...
  151.     Salida:      void (nada)
  152. */
  153. void MF_AbreMiVentana(void)
  154. {
  155.     /* Declaración e inicialización de una variable de tipo Rect */                    
  156.     Rect    miRectangulo = { 48, 8,108, 300 };    
  157.     
  158.     gMiVentana = NewWindow(    nil,
  159.                                                     &miRectangulo,
  160.                                                     "\pC de Cerca - 1",
  161.                                                     true,
  162.                                                     documentProc,
  163.                                                     (WindowPtr)-1L,
  164.                                                     false,
  165.                                                     nil);
  166.   
  167.   if(gMiVentana == nil) 
  168.           ExitToShell();    /* Si la creación de la ventana falla, 
  169.                                               posiblemente sea debido a falta de memoria libre
  170.                                               Lo más aconsejable es salir de la aplicación YA, 
  171.                                               empleando ExitToShell()
  172.                                           */
  173.       
  174. } /* Fin de MF_AbreMiVentana() */
  175.  
  176.  
  177.  
  178. /****************************************************************/
  179. /* MF_EscribeTexto                                                                                         */ 
  180. /****************************************************************/
  181. /*
  182.     Dibuja en nuestra ventana un texto.
  183.         
  184.     Recibe:     nada
  185.     Cambia:      Escribe un texto en la ventana
  186.     Salida:   nada
  187. */
  188. void MF_EscribeTexto()
  189. {
  190.  
  191.     SetPort(gMiVentana);
  192.     MoveTo(15,20);
  193.     DrawString("\pLa mínima expresión de un programa en C.");
  194.     MoveTo(15,35);
  195.     DrawString("\pHaga clic para salir...");
  196.              
  197. } /* Fin de MF_EscribeTexto() */